﻿#include <iostream>
#include <thread>
#include <atomic>
#include <random>
#include <chrono>
#include <vector>

using namespace std;

atomic<bool> isChannelBusy(false); // 使用原子变量替代互斥锁
const int NUM_NODES = 5;
const int MAX_RETRIES = 10;
const int SLOT_TIME = 200; // 微秒为单位的时间片

// 改进的指数退避算法
int getRandomBackoff(int attempt) {
    random_device rd;
    mt19937 gen(rd());
    int max_slots = (1 << min(attempt, 10)) - 1; // 限制最大退避次数
    uniform_int_distribution<> dist(0, max_slots);
    return dist(gen) * SLOT_TIME;
}

class Node {
public:
    Node(int id) : id(id) {}

    void transmit() {
        int retries = 0;

        while (retries < MAX_RETRIES) {
            // 载波监听阶段
            bool expected = false;
            if (isChannelBusy.compare_exchange_strong(expected, true)) {
                // 成功占用信道
                cout << "节点 " << id << " 开始发送数据..." << endl;

                // 模拟传输时延（传播时间）
                this_thread::sleep_for(chrono::microseconds(10));

                // 冲突检测（检查信道是否仍被自己独占）
                if (isChannelBusy.load()) { // 未发生冲突
                    // 完整传输数据
                    this_thread::sleep_for(chrono::milliseconds(2));
                    cout << "节点 " << id << " 发送成功！" << endl;
                    isChannelBusy.store(false);
                    return;
                }
                else { // 检测到冲突
                    cout << "节点 " << id << " 检测到冲突！" << endl;
                    isChannelBusy.store(false);
                    int backoff = getRandomBackoff(retries);
                    this_thread::sleep_for(chrono::microseconds(backoff));
                    retries++;
                }
            }
            else { // 信道忙碌
                // 随机等待后重试
                this_thread::sleep_for(chrono::microseconds(
                    getRandomBackoff(0) // 使用基础退避时间
                ));
            }
        }
        cout << "节点 " << id << " 超过最大重试次数，发送失败！" << endl;
    }

private:
    int id;
};

int main() {
    vector<thread> threads;

    for (int i = 0; i < NUM_NODES; ++i) {
        threads.emplace_back([i]() {
            Node node(i + 1);
            node.transmit();
            });
    }

    for (auto& t : threads) {
        t.join();
    }

    cout << "所有节点传输完成。" << endl;
    return 0;
}